//package util;
//
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
//import com.mexue.common.enums.RedisCacheEnums;
//import com.mexue.framework.config.AppConfig;
//
//import redis.clients.jedis.JedisPool;
//import redis.clients.jedis.JedisPoolConfig;
//import redis.clients.jedis.JedisPubSub;
//import redis.clients.jedis.JedisShardInfo;
//import redis.clients.jedis.ShardedJedisPool;
//import redis.clients.jedis.Transaction;
//import redis.clients.jedis.TransactionBlock;
//
///**
// * <br/>
// * 项目名称：mexue2 <br/>
// * 类名称：RedisManager <br/>
// * 类描述：redis工厂类定义<br/>
// * 创建人：liuy <br/>
// * 创建时间：2015年8月19日 下午4:20:32 <br/>
// * 修改人：liuy <br/>
// * 修改时间：2015年8月19日 下午4:20:32 <br/>
// * 修改备注： <br/>
// * @version <br/>
// * <br/>
// */
//public class RedisManager {
//
//	static JedisOperations jedis = null;
//	
//	static protected String serverlist = "192.168.2.56:6379"; // 用逗号(,)分隔的"ip:port"列表
//	static protected int maxActive = 500;
//	static protected int minIdle = 20;
//	static protected int maxIdle = 200;
//	static protected long maxWait = 3000L;
//	static protected int socketTO = 6000;
//	static protected boolean testOnBorrow = true;
//	
//	static protected String persistenceRedisServerlist = "192.168.2.53:6379,192.168.2.54:6379";
//	static protected int persistenceRedisMaxActive = 500;
//	static protected int persistenceRedisMinIdle = 20;
//	static protected int persistenceRedisMaxIdle = 200;
//	static protected long persistenceRedisMaxWait = 3000L;
//	static protected int persistenceRedisSocketto = 6000;
//	static protected boolean persistenceRedisTestOnBorrow = true;
//
//	static protected String persistenceRedisBizHomeworkPageNum = "5";
//	static protected String persistenceRedisBizHomeworkPageSize = "10";
//	
//	/**
//	 * Singleton pattern: single instance.
//	 */
//	private static RedisManager instance;
//	
//	/**
//	 * Singleton pattern: protected constructor needed for derived classes.
//	 */
//	protected RedisManager() {}
//	
//	static{
//		instance = new RedisManager();
//		
//		if(AppConfig.getConfigProps().size() > 0){
//			serverlist = AppConfig.getProperty("redis.serverlist");
//			minIdle = AppConfig.getIntProperty("redis.minIdle");
//			maxActive = AppConfig.getIntProperty("redis.maxActive");
//			maxIdle = AppConfig.getIntProperty("redis.maxIdle");
//			maxWait = AppConfig.getIntProperty("redis.maxWait");
//			testOnBorrow = AppConfig.getBooleanProperty("redis.testOnBorrow");
//			socketTO = AppConfig.getIntProperty("redis.socketto");
//
//			persistenceRedisServerlist = AppConfig.getProperty("persistence.redis.serverlist");
//			persistenceRedisMinIdle = AppConfig.getIntProperty("persistence.redis.minIdle");
//			persistenceRedisMaxActive = AppConfig.getIntProperty("persistence.redis.maxActive");
//			persistenceRedisMaxIdle = AppConfig.getIntProperty("persistence.redis.maxIdle");
//			persistenceRedisMaxWait = AppConfig.getIntProperty("persistence.redis.maxWait");
//			persistenceRedisTestOnBorrow = AppConfig.getBooleanProperty("persistence.redis.testOnBorrow");
//			persistenceRedisSocketto = AppConfig.getIntProperty("persistence.redis.socketto");
//			
//			persistenceRedisBizHomeworkPageNum = AppConfig.getProperty("persistence.redis.biz.homework.pageNum");
//			persistenceRedisBizHomeworkPageSize = AppConfig.getProperty("persistence.redis.biz.homework.pageSize");			
//		}
//	}
//	
//	public static RedisManager getInstance() {
//		return getInstance(RedisCacheEnums.getRedisCacheTypeEnumOneCode());
//	}
//	
//	/**
//	 * Singleton pattern: get single instance.
//	 */
//	public static RedisManager getInstance(int type) {
//		if(type == 0) type = RedisCacheEnums.getRedisCacheTypeEnumOneCode();
//		
//		if(type == RedisCacheEnums.getRedisCacheTypeEnumOneCode())//原来的jedis访问配置
//			setPoolConfig(maxActive,minIdle,maxIdle,maxWait,testOnBorrow,serverlist,socketTO);
//		else if(type == RedisCacheEnums.getRedisCacheTypeEnumTwoCode())//新配置
//			setPoolConfig(persistenceRedisMaxActive,persistenceRedisMaxActive,persistenceRedisMaxIdle,persistenceRedisMaxWait,
//					persistenceRedisTestOnBorrow,persistenceRedisServerlist,persistenceRedisSocketto);
//		
//		return instance;
//	}
//	
//	/**
//	 * 设置PoolConfig参数 <br/>
//	 * setPoolConfig <br/>
//	 * @param redisMaxActive 控制池中对象的最大数量 默认值是8，如果是负值表示没限制<br/>
//	 * @param redisMinIdle 控制池中空闲的对象的最小数量。默认值是0<br/>
//	 * @param redisMaxIdle 控制池中空闲的对象的最小数量。默认值是0<br/>
//	 * @param redisMaxWait 如果maxWait是正数，那么会等待maxWait的毫秒的时间，超时会抛出NoSuchElementException异常；如果maxWait为负值，会永久等待。
//	 *                     maxWait的默认值是-1<br/>
//	 * @param redisTestOnBorrow 如果testOnBorrow被设置，pool会在borrowObject返回对象之前使用PoolableObjectFactory的validateObject来验证这个对象是否有效，
//	 *                          要是对象没通过验证，这个对象会被丢弃，然后重新选择一个新的对象。testOnBorrow的默认值是false<br/>
//	 * @param redisServerlist redis server列表<br/>
//	 * @param redisSocketto Socket Timeout<br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	private static Object[] setPoolConfig(int redisMaxActive,int redisMinIdle,int redisMaxIdle,long redisMaxWait,
//			boolean redisTestOnBorrow,String redisServerlist,int redisSocketto){
//		JedisPoolConfig poolConfig = new JedisPoolConfig();
//		
//		poolConfig.setMaxTotal(redisMaxActive);
//		poolConfig.setMinIdle(redisMinIdle);
//
//		poolConfig.setMaxIdle(redisMaxIdle);
//		
//		poolConfig.setMaxWaitMillis(redisMaxWait * 1000);
//		poolConfig.setTestOnBorrow(redisTestOnBorrow);
//		poolConfig.setTestOnReturn(true);
//		poolConfig.setTestWhileIdle(true);
//		poolConfig.setMinEvictableIdleTimeMillis(1000L * 60L * 10L); // 空闲对象,空闲多长时间会被驱逐出池里
//		poolConfig.setTimeBetweenEvictionRunsMillis(1000L * 30L); // 驱逐线程30秒执行一次
//		poolConfig.setNumTestsPerEvictionRun(-1); // -1,表示在驱逐线程执行时,测试所有的空闲对象
//		
//		String[] servers = redisServerlist.split(",");
//		List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(servers.length);
//		for (int i = 0; i < servers.length; i++) {
//			String[] hostAndPort = servers[i].split(":");
//			String host = hostAndPort[0];
//			int port = Integer.parseInt(hostAndPort[1]);
//			JedisShardInfo shardInfo = new JedisShardInfo(host, port, redisSocketto);
//			if (hostAndPort.length == 3) {
//				shardInfo.setPassword(hostAndPort[2]);
//			}
//			shards.add(shardInfo);
//		}
//		
//		if (shards.size() == 1) {
//			JedisPool pool = new JedisPool(poolConfig, shards.get(0).getHost(), shards.get(0).getPort(), 
//					shards.get(0).getTimeout(), shards.get(0).getPassword());
//			jedis = new BasicJedisOperations(pool);
//		} else {
//			ShardedJedisPool pool = new ShardedJedisPool(poolConfig, shards);
//			jedis = new ShardedJedisOperations(pool);
//		}
//		
//		return new Object[]{poolConfig,shards};
//	}
//	
//	
//	
//
//	/**
//	 * Redis基本（键）操作
//	 * 删除
//	 * @return 被删除 key 的数量
//	 */
//	public Long delete(String... keys){
//		return jedis.del(keys);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 返回 key 所储存的值的类型。
//	 * @return none(key不存在)，string(字符串)，list(列表)，set(集合)，zset(有序集)，hash(哈希表)
//	 */
//	public String type(String key){
//		return jedis.type(key);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 获取键列表
//	 */
//	public Set<String> keys(String pattern){
//		return jedis.keys(pattern);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 查看某个key的剩余生存时间:time to live
//	 * @return 当 key 不存在或没有设置生存时间时，返回 -1 。否则，返回 key 的剩余生存时间(以秒为单位)。
//	 */
//	public Long ttl(String key){
//		return jedis.ttl(key);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 查看某个key是否存在
//	 * @param key
//	 * @return
//	 */
//	public Boolean exists(String key){
//		return jedis.exists(key);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 设置某一记录的生存时间，过期删除
//	 * @param key 设置可挥发的key
//	 * @param seconds 超时时间，单位：秒
//	 * @return
//	 */
//	public Long expire(String key, int seconds){
//		return jedis.expire(key, seconds);
//	}
//	
//	/**
//	 * Redis基本（键）操作
//	 * 移除给定 key 的生存时间，将这个 key从可挥发的(带生存时间 key )转换成持久化的(一个不带生存时间、永不过期的 key )
//	 * @param key
//	 * @return
//	 */
//	public Long persist(String key){
//		return jedis.persist(key);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将设置某个key的值，如果 key 已经持有其他值，就覆写旧值，无视类型。
//	 * @param key
//	 * @param value
//	 * @return
//	 */
//	public String set(String key, String value){
//		return jedis.set(key, value);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将 key 的值设为 value ，当且仅当 key不存在，若给定的 key 已经存在，则 SETNX 不做任何动作。
//	 * set not exists
//	 * @param value
//	 * @return
//	 */
//	public Long setnx(String key, String value){
//		return jedis.setnx(key, value);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
//	 * @param key
//	 * @param seconds
//	 * @param value
//	 * @return
//	 */
//	public String setex(String key, int seconds, String value){
//		return jedis.setex(key, seconds, value);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 返回 key 所关联的字符串值。
//	 * @param key
//	 * @return
//	 */
//	public String get(String key){
//		return jedis.get(key);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将 key 中储存的数字值增一。
//	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
//	 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//	 * @param key
//	 * @return
//	 */
//	public Long incr(String key){
//		return jedis.incr(key);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将 key 中储存的数字值增加固定制。
//	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
//	 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//	 * @param key
//	 * @return
//	 */
//	public Long incrBy(String key, long increase){
//		return jedis.incrBy(key, increase);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将 key 中储存的数字值减一。
//	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
//	 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//	 * @param key
//	 * @return
//	 */
//	public Long decr(String key){
//		return jedis.decr(key);
//	}
//	
//	/**
//	 * Redis基本（字符串）操作
//	 * 将 key 中储存的数字值减少固定制。
//	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
//	 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//	 * @param key
//	 * @return
//	 */
//	public Long decrBy(String key, long decrease){
//		return jedis.decrBy(key, decrease);
//	}
//	
//	/**
//	 * Hash操作
//	 * 设置字段值
//	 * @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1；如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
//	 */
//	public Long hset(String hkey, String field, String value){
//		return jedis.hset(hkey, field, value);
//	}
//	
//	/**
//	 * Hash操作
//	 * 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在
//	 * 若域 field 已经存在，该操作无效。
//	 * 如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令
//	 * @return 设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。
//	 */
//	public Long hsetnx(String hkey, String field, String value){
//		return jedis.hsetnx(hkey, field, value);
//	}
//	
//	/**
//	 * Hash操作
//	 * 同时将多个 field-value (域-值)对设置到哈希表 key 中
//	 * 此命令会覆盖哈希表中已存在的域
//	 * 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
//	 * @return 如果命令执行成功，返回 OK 
//	 */
//	public String hmset(String hkey, Map<String, String> hash){
//		return jedis.hmset(hkey, hash);
//	}
//	
//	/**
//	 * Hash操作
//	 * 返回哈希表 key 中给定域 field 的值。
//	 * @return 给定域的值
//	 */
//	public String hget(String hkey, String field){
//		return jedis.hget(hkey, field);
//	}
//	
//	/**
//	 * Hash操作
//	 * 返回哈希表中，所有的域和值
//	 * @return 以列表形式返回哈希表的域和域的值
//	 */
//	public Map<String, String> hgetAll(String hkey){
//		return jedis.hgetAll(hkey);
//	}
//	
//	/**
//	 * Hash操作
//	 * 删除哈希表中的一个字段，字段不存在将被忽略
//	 * @return 被成功移除的域的数量，不包括被忽略的域
//	 */
//	public Long hdel(String hkey, String field){
//		return jedis.hdel(hkey, field);
//	}
//	
//	/**
//	 * Hash操作
//	 * 返回哈希表中字段的数量
//	 * @return 哈希表中域的数量，当 key 不存在时，返回 0 。
//	 */
//	public Long hlen(String hkey){
//		return jedis.hlen(hkey);
//	}
//	
//	/**
//	 * Hash操作
//	 * 查看哈希表 key 中，给定field 是否存在
//	 * @return
//	 */
//	public Boolean hexists(String hkey, String field){
//		return jedis.hexists(hkey, field);
//	}
//	
//	/**
//	 * Hash操作
//	 * 为哈希表 key 中的域 field 的值加上增量 increment
//	 * @return
//	 */
//	public Long hincrBy(String hkey, String field, long increment){
//		return jedis.hincrBy(hkey, field, increment);
//	}
//	
//	/**
//	 * Hash操作
//	 * 返回哈希表 key 中的所有域
//	 * @return
//	 */
//	public Set<String> hkeys(String hkey){
//		return jedis.hkeys(hkey);
//	}
//	
//	/**
//	 * Hash操作
//	 * 返回哈希表 key 中所有域的值
//	 * @return
//	 */
//	public List<String> hvals(String hkey){
//		return jedis.hvals(hkey);
//	}
//	
//	/**
//	 * List操作
//	 * 将一个值 value 插入到列表 key 的表头
//	 * 当 key 存在但不是列表类型时，返回一个错误
//	 * @return 执行 LPUSH 命令后，列表的长度
//	 */
//	public Long lpush(String lkey, String value){
//		return jedis.lpush(lkey, value);
//	}
//	
//	/**
//	 * List操作
//	 * 将一个值 value 插入到列表 key 的表尾(最右边)
//	 * 当 key 存在但不是列表类型时，返回一个错误
//	 * @return 执行 RPUSH 操作后，列表的长度
//	 */
//	public Long rpush(String lkey, String value){
//		return jedis.rpush(lkey, value);
//	}
//	
//	/**
//	 * List操作
//	 * 移除并返回列表 key 的头元素
//	 * @return 列表的头元素
//	 */
//	public String lpop(String lkey){
//		return jedis.lpop(lkey);
//	}
//	
//	/**
//	 * List操作
//	 * 移除并返回列表 key 的尾元素
//	 * @return 列表的尾元素
//	 */
//	public String rpop(String lkey){
//		return jedis.rpop(lkey);
//	}
//	
//	/**
//	 * List操作
//	 * @return 返回列表的长度
//	 */
//	public Long llen(String lkey){
//		return jedis.llen(lkey);
//	}
//	
//	/**
//	 * List操作
//	 * 返回列表中指定区间内的元素，区间以偏移量 start 和 end 指定
//	 * 也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推
//	 * @return
//	 */
//	public List<String> lrange(String lkey, int start, int end){
//		return jedis.lrange(lkey, start, end);
//	}
//	
//	/**
//	 * List操作
//	 * 根据参数 count 的值，移除列表中与参数 value 相等的元素
//	 * count = 0 : 移除表中所有与 value 相等的值
//	 * count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count
//	 * count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值
//	 * @return 被移除元素的数量
//	 */
//	public Long lrem(String lkey, int count, String value){
//		return jedis.lrem(lkey, count, value);
//	}
//	
//	/**
//	 * List操作
//	 * 将列表 key 下标为 index 的元素的值设置为 value
//	 * @return
//	 */
//	public String lset(String lkey, long index, String value){
//		return jedis.lset(lkey, index, value);
//	}
//	
//	/**
//	 * Set操作
//	 * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
//	 * 假如 key 不存在，则创建一个只包含 member 元素作成员的集合
//	 * 当 key 不是集合类型时，返回一个错误
//	 * @return 被添加到集合中的新元素的数量，不包括被忽略的元素
//	 */
//	public Long sadd(String skey, String member){
//		return jedis.sadd(skey, member);
//	}
//	
//	/**
//	 * Set操作
//	 * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
//	 * @return 被成功移除的元素的数量，不包括被忽略的元素。
//	 */
//	public Long srem(String skey, String member){
//		return jedis.srem(skey, member);
//	}
//
//	/**
//	 * Set操作
//	 * 返回集合 key 中的所有成员
//	 * 不存在的 key 被视为空集合
//	 * @return 集合中的所有成员
//	 */
//	public Set<String> smembers(String skey){
//		return jedis.smembers(skey);
//	}
//	
//	/**
//	 * Set操作
//	 * 判断 member 元素是否集合 key 的成员
//	 * @return 如果 member 元素是集合的成员，返回true
//	 */
//	public Boolean sismember(String skey, String member){
//		return jedis.sismember(skey, member);
//	}
//	
//	/**
//	 * Set操作
//	 * 返回集合 key 的基数(集合中元素的数量)
//	 * @return 集合的基数
//	 */
//	public Long scard(String skey){
//		return jedis.scard(skey);
//	}
//	
//	/**
//	 * Set操作
//	 * 移除并返回集合中的一个元素
//	 * @return 被移除的元素
//	 */
//	public String spop(String skey){
//		return jedis.spop(skey);
//	}
//	
//	/**
//	 * Set操作
//	 * 返回一个集合的全部成员，该集合是所有给定集合的交集
//	 * 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
//	 * @return 交集成员的列表
//	 */
//	public Set<String> sinter(String... skeys){
//		return jedis.sinter(skeys);
//	}
//	
//	/**
//	 * Set操作
//	 * 返回一个集合的全部成员，该集合是所有给定集合的并集
//	 * @return 并集成员的列表
//	 */
//	public Set<String> sunion(String... skeys){
//		return jedis.sunion(skeys);
//	}
//	
//	/**
//	 * Set操作
//	 * 返回一个集合的全部成员，该集合是所有给定集合之间的差集
//	 * @return 交集成员的列表
//	 */
//	public Set<String> sdiff(String... skeys){
//		return jedis.sdiff(skeys);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 将一个 member 元素及其 score 值加入到有序集 key 当中
//	 * @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
//	 */
//	public Long zadd(String zkey, double score, String member){
//		return jedis.zadd(zkey, score, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
//	 * 当 key 不是集合类型，返回一个错误
//	 * @return 被成功移除的元素的数量，不包括被忽略的元素
//	 */
//	public Long zrem(String zkey, String member){
//		return jedis.zrem(zkey, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 的基数
//	 * @return 当 key 存在且是有序集类型时，返回有序集的基数；当 key 不存在时，返回 0 
//	 */
//	public Long zcard(String zkey){
//		return jedis.zcard(zkey);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员
//	 * @return score 值在 min 和 max 之间的成员的数量
//	 */
//	public Long zcount(String zkey, double min, double max){
//		return jedis.zcount(zkey, min, max);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中，成员 member 的 score 值
//	 * @return member 成员的 score 值
//	 */
//	public Double zscore(String zkey, String member){
//		return jedis.zscore(zkey, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 为有序集 key 的成员 member 的 score 值加上增量 increment
//	 * @return member 成员的新 score 值
//	 */
//	public Double zincrby(String zkey, double increment, String member){
//		return jedis.zincrby(zkey, increment, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中，指定区间内的成员
//	 * 其中成员的位置按 score 值递增(从小到大)来排序
//	 * 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推
//	 * @return 指定区间内，有序集成员的列表
//	 */
//	public Set<String> zrange(String zkey, int start, int end){
//		return jedis.zrange(zkey, start, end);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中，指定区间内的成员
//	 * 其中成员的位置按 score 值递减(从大到小)来排序
//	 * 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推
//	 * @return 指定区间内，有序集成员的列表
//	 */
//	public Set<String> zrevrange(String zkey, int start, int end){
//		return jedis.zrevrange(zkey, start, end);
//	}
//	
//	/**
//	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
//	 * @param zkey
//	 * @param min
//	 * @param max
//	 * @return
//	 */
//	public Set<String> zrangeByScore(String zkey, double min, double max){
//		return jedis.zrangeByScore(zkey, min, max);
//	}
//	
//	/**
//	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
//	 * 有序集成员按 score 值递增(从小到大)次序排列。
//	 * @param zkey
//	 * @param min 在不知道最小值时，可以用 -inf代替最小值
//	 * @param max 在不知道最大值时，可以用 +inf代替最大值
//	 * @return
//	 */
//	public Set<String> zrangeByScore(String zkey, String min, String max){
//		return jedis.zrangeByScore(zkey, min, max);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
//	 * @return 如果 member 是有序集 key 的成员，返回 member 的排名
//	 */
//	public Long zrank(String zkey, String member){
//		return jedis.zrank(zkey, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序
//	 * @return 如果 member 是有序集 key 的成员，返回 member 的排名
//	 */
//	public Long zrevrank(String zkey, String member){
//		return jedis.zrevrank(zkey, member);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
//	 * @return 被移除成员的数量
//	 */
//	public Long zremrangeByScore(String zkey, double start, double end){
//		return jedis.zremrangeByScore(zkey, start, end);
//	}
//	
//	/**
//	 * Sorted set操作（有序集）
//	 * 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
//	 * @param zkey
//	 * @param start 在不知道最小值时，可以用 -inf代替最小值
//	 * @param end 在不知道最大值时，可以用 +inf代替最大值
//	 * @return
//	 */
//	public Long zremrangeByScore(String zkey, String start, String end){
//		return jedis.zremrangeByScore(zkey, start, end);
//	}
//	
//	/**
//	 * 事务操作
//	 * 事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行。
//	 * @param block
//	 * @return
//	 */
//	public List<Object> multiResult(TransactionBlock block){
//		return jedis.multiResult(block);
//	}
//	
//	/**
//	 * 事务操作
//	 * 标记一个事务块的开始
//	 * @return Transaction对象，可基于Transaction操作
//	 */
//	public Transaction multi(){
//		return jedis.multi();
//	}
//	
//	public Long publish(String channel, String message){
//		return jedis.publish(channel, message);
//	}
//	
//	public void subscribe(JedisPubSub pubSub, String... channels){
//		jedis.subscribe(pubSub, channels);
//	}
//	
//	/**
//	 * 序列号对象 <br/>
//	 * serializable <br/>
//	 * @param obj 要序列号的对象<br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public byte[] serializable(Object obj){
//		return jedis.serializable(obj);
//	}
//	
//	/**
//	 * 反序列号对象 <br/>
//	 * unserialize <br/>
//	 * @param  <br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public Object unserialize(byte[] bytes){
//		return jedis.unserialize(bytes);
//	}
//	
//	/**
//	 * 向redis中设置对象值 <br/>
//	 * set <br/>
//	 * @param key 二进制key<br/>
//	 * @param value 二进制value<br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public void set(byte[] key, byte[] value){
//		set(key,value,0);
//	}
//	
//	/**
//	 * 向redis中设置对象值 <br/>
//	 * set <br/>
//	 * @param key 二进制key<br/>
//	 * @param value 二进制value<br/>
//	 * @param exp 失效时间，默认为0,意思是不限制key的失效时间<br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public void set(byte[] key, byte[] value, int exp){
//		jedis.set(key,value,exp);
//	}
//	/**
//	 * 从redis中获取对象值 <br/>
//	 * get <br/>
//	 * @param key 二进制key<br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public byte[] get(byte[] key){
//		return jedis.get(key);
//	}
//	/**
//	 * 从redis中根据key删除对象值<br/>
//	 * del <br/>
//	 * @param  <br/>
//	 * @throws <br/>
//	 * @since Ver1.0 <br/>
//	 *  <br/>
//	 */
//	public long del(byte[] key){
//		return jedis.del(key);
//	}
//	
//}
